import java.math.BigDecimal;
import java.math.RoundingMode;

/**
 * Description:
 * Date: 2025-10-21
 * Time: 22:39
 */

class Student {
    public String name;
    public int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class Test {
    //String类 ：表示字符串，是一个引用类型

    public static void main1(String[] args) {
        //字符串的初始化

        //直接赋值
        String s1 = "hello";
        //new一个新对象赋值
        String s2 = new String("world");

        //使用字符数组进行构造
        char[] ch = {'a','b','c','D'};
        String s3 = new String(ch);

        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
    }

    public static void main2(String[] args) {
        //String对象之间的比较
        String s1 = "hello";
        String s2 = "world";
        String s3 = s1;//s1将自己指向堆中的内存空间的访问地址给了s3，此时s1和s3指向同一个内存空间

        //s1与s2中存的内存地址不一样，s1和s3中存的内存地址一样
        //使用等于号 == 比较，因为String类是引用类型，所以是内存地址的直接比较，而不是内存空间中存的数据进行的比较
        System.out.println(s1 == s2);//false
        System.out.println(s2 == s3);//false
        System.out.println(s3 == s1);//true

        //字符串是不可变的，此时是将一个新的内存空间的地址给了s3中
        s3 = "hell";
        System.out.println(s1);
        System.out.println(s3);
    }

    public static void main3(String[] args) {
        String s1 = "hello";
        String s2 = "Hello";
        String s3 = "hello";

        //equals()方法是对两个字符串中的每个字符进行对比，
        //区分大小写，只关心相不相等，不关心谁大谁小
        System.out.println(s1.equals(s2));//false
        System.out.println(s1.equals(s3));//true
        System.out.println(s2.equals(s3));//false
    }

    public static void main4(String[] args) {
        String s1 = "hello";
        String s2 = "Hello";
        String s3 = "world";

        //compareTo()方法，字符串之间的比较
        //决定大小的判定：1.先看第一个字母的大小，若第一个字母大,则就是大
        //    2.若每一个字母都相同，但其中一个字符串长，则长度长的大
        System.out.println(s1.compareTo(s2));// >0
        System.out.println(s1.compareTo(s3));// <0
        System.out.println(s3.compareTo(s2));// >0
        //调用可以忽略大小写影响的compareToIgnoreCase()方法
        System.out.println(s1.compareToIgnoreCase(s2));

        String s4 = "hel";
        String s5 = "w";
        String s6 = "he";
        System.out.println(s4.compareTo(s5));
        System.out.println(s4.compareTo(s6));
    }

    public static void main5(String[] args) {
        //字符串查找

        String s1 = "helloworld";
        System.out.println(s1.charAt(5));

        System.out.println(s1.indexOf("wo"));
        System.out.println(s1.indexOf("l",5));
        //从后往前找，返回所要找字符串的下标
        System.out.println(s1.lastIndexOf("l",5));
    }

    public static void main6(String[] args) {
        //字符串转化

        //数字转字符串 valueOf()方法
        String s1 = String.valueOf(1234);//整型转化
        String s2 = String.valueOf(13.14);//字符型转化
        String s3 = String.valueOf(true);//boolean类型转化
        String s4 = String.valueOf(new Student("zhangsan", 21));//类转化

        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s4);
    }

    public static void main7(String[] args) {
        //字符串转数字

        //使用所要转的类型的包装类，用包装类调用valueOf()方法
        int data1 = Integer.valueOf("1234");
        double data2 = Double.valueOf("13.14");
        System.out.println(data1);
        System.out.println(data2);
    }

    public static void main8(String[] args) {
        //字符串大小写转化
        //只对字符串中的英文字母进行转化，其余的字符不理会
        String s1 = "helLo!~!";
        String s2 = "Wor拟ld";

        System.out.println(s1.toUpperCase());
        System.out.println(s2.toLowerCase());
    }

    public static void main9(String[] args) {
        //字符串转数组
        String s1 = "hello world!";
        char[] ch = s1.toCharArray();
        for(char c : ch){
            System.out.print(c + " ");
        }
        System.out.println();
        //数组转字符串
        char[] chars = {'a','b','c','d','E'};
        String s2 = new String(chars);
        System.out.println(s2);
    }

    public static void main10(String[] args) {
        //格式化
        String s = String.format("%d-%d!%d",2025,13,01);

        System.out.println(s);

        double data = 13.1415926;
        System.out.printf("%.2f\n",data);

        double data2 = 5.201314;
        String str = String.format("%.2f", data2);
        double d = Double.parseDouble(str);
        System.out.println(d);
    }

    public static void main11(String[] args) {
        //字符串替换
        String s = "ababcabcd";
        String str = s.replace('a','t');
        System.out.println(str);

        str = s.replace("ab", "hg");
        System.out.println(str);

        str = s.replaceAll("a", "t");
        System.out.println(str);

        str = s.replaceFirst("c","k");
        System.out.println(str);

        //注：因为字符串是不可变的，所有改变后的字符串都是生成一个新的字符串，再进行赋值
    }

    public static void main12(String[] args) {
        //字符串拆分
        String s = "name=zhangsan&age=21";
        String[] str = s.split("&");
        for (String s1 : str){
            System.out.println(s1);
        }

        str = s.split("&|=");//拆分多个符号时，|两边不加空格
        for (String s1 : str){
            System.out.println(s1);
        }

        str = s.split("&|=",2);//limit:表示拆分后的字符串分为两部分
        for (String s1 : str){
            System.out.println(s1);
        }

        //split()的参数是正则表达式。部分字符再字符串中需要进行转义
        s = "192.168.0.1";
        str = s.split("\\.");//正则表达式中：\\. 表示 .
        for (String s1 : str){
            System.out.println(s1);
        }
    }

    public static void main13(String[] args) {
        //字符串截取

        String s = "hello world!";
        String str = s.substring(4);//从索引4下表开始(包括4下标)，一直到结尾
        System.out.println(str);

        str = s.substring(1,7);//java中的区间是左闭右开：[1，7)，所以截取字符串从索引1到索引6下标之间的字符串
        System.out.println(str);
    }

    public static void main14(String[] args) {
        //去掉字符串两端的空格
        String s = "   he llo wo rld!    ";
        System.out.println(s);
        String str = s.trim();
        //只去除两端的全部空格，位于字符串内的空格不会去除
        System.out.println(str);
    }


    //StringBuilder 和 StringBuffer
    public static void main15(String[] args) {
        //当对String类进行直接修改时，因为String时不可变的，每次修改都会创建一个新对象
        //则当需要创建多个对象时，可以使用StringBuilder 和 StringBuffer

        //注：StringBuilder 和 StringBuffer 不是字符串类本身
        //  而是一个用于操控字符串的“可变字符序列类”

        //String -->字符串类本身
        //StringBuilder和StringBuffer -->表示一个字符串构造器(用于拼接和修改字符串)

        String s = "";
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            s += i;//Sting类每次修改需要创建对象
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);

        start = System.currentTimeMillis();
        StringBuilder stringBuilder = new StringBuilder("");
        for (int i = 0; i < 10000; i++) {
            stringBuilder.append(i);//会在原来的字符串上进行修改，不需要创建新对象，速度快
        }
        end = System.currentTimeMillis();
        System.out.println(end - start);


        start = System.currentTimeMillis();
        StringBuffer stringBuffer = new StringBuffer("");
        for (int i = 0; i < 10000; i++) {
            stringBuffer.append(i);//会在原来的字符串上进行修改，不需要创建新对象，速度快
        }
        end = System.currentTimeMillis();
        System.out.println(end - start);
    }

    public static void main(String[] args) {
        //StringBuilder 和 StringBuffer 大部分方法都和String类一样

        //与String不同的方法
        StringBuffer s = new StringBuffer("hello world!");
        String s1 = "ababcabcd";
        StringBuilder s2 = new StringBuilder(s1);

        //toString()将所有字符按照String的方式返回
        String str = s.toString();
        System.out.println(str);
        str = s2.toString();
        System.out.println(str);

        //反转字符串
        System.out.println(s2.reverse());

    }


}
